// 《围棋》作者版权所有。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 包netip定义了一个小值类型的IP地址类型。
// 在该Addr类型的基础上，该包还定义了AddrPort（一个
// IP地址和一个端口）和Prefix（一个IP地址和一个位长度
// Prefix）。
// 
// 与网络相比。IP类型，这个包的Addr类型占用更少的
// 内存，是不可变的，并且具有可比性（支持==并且是
// 映射键）。
package netip

import (
	"errors"
	"math"
	"strconv"

	"internal/bytealg"
	"internal/intern"
	"internal/itoa"
)

// 大小：（64位）
// 净。IP:24字节片头+{4，16}=28到40字节
// net。IPAddr:40字节片头+{4，16}=44到56字节+区域长度
// netip。Addr:24字节（区域是每个名称的单例，在所有用户之间共享）

// Addr表示一个IPv4或IPv6地址（有或没有作用域
// 寻址区域），类似于net。IP或网络。IPAddr。
// 
// 不同于网络。IP或网络。IPAddr，Addr是一个可比较的值
// type（它支持==并且可以是一个映射键），并且是不可变的。
// 
// 零地址不是有效的IP地址。
// Addr{}不同于0.0.0.0和：：。
type Addr struct {
	// addr是IPv6地址的高位和低位。如果z==z4，则
	// hi和lo包含IPv4映射的IPv6地址。
	// 
	// hi和lo是通过将16字节的IPv6 
	// 地址解释为一个大端128位数字来构造的。最重要的
	// 该数字的位进入hi，其余进入lo。例如，0011:2233:4455:6677:8899:aabb:ccdd:eeff存储为：
	// addr。hi=0x0011223344556677 
	// 地址。lo=0x8899aabbccddeeff 
	// 
	// 我们这样存储IP，而不是作为[16]字节，因为它
	// 将IP上的大多数操作转换为算术和位旋转
	// 64位寄存器上的操作，这比
	// 字节处理快得多。
	addr uint128

	// z是地址系列和IPv6区域的组合。
	// 
	// nil表示无效的IP地址（对于零地址）。
	// z4表示IPv4地址。
	// z6noz表示没有区域的IPv6地址。
	// 
	// 否则是被拘留的区域名称字符串。
	z *intern.Value
}

// z0、z4和z6noz是哨兵IP。z值。wen dang
var (
	z0    = (*intern.Value)(nil)
	z4    = new(intern.Value)
	z6noz = new(intern.Value)
)

// IPv6LinkLocalAllNodes返回IPv6链路本地所有节点多播
// 地址ff02:：1。
func IPv6LinkLocalAllNodes() Addr { return AddrFrom16([16]byte{0: 0xff, 1: 0x02, 15: 0x01}) }

// IPv6Unspecified返回未指定的IPv6地址“：”。
func IPv6Unspecified() Addr { return Addr{z: z6noz} }

// IPv4Unspecified返回未指定的IPv4地址“0.0.0.0”。
func IPv4Unspecified() Addr { return AddrFrom4([4]byte{}) }

// AddrFrom4返回由addr中的字节给出的IPv4地址的地址。
func AddrFrom4(addr [4]byte) Addr {
	return Addr{
		addr: uint128{0, 0xffff00000000 | uint64(addr[0])<<24 | uint64(addr[1])<<16 | uint64(addr[2])<<8 | uint64(addr[3])},
		z:    z4,
	}
}

// AddrFrom16返回由addr中的字节给出的IPv6地址。
// IPv6映射的IPv4地址保留为IPv6地址。
// （如果需要，使用Unmap转换。）
func AddrFrom16(addr [16]byte) Addr {
	return Addr{
		addr: uint128{
			beUint64(addr[:8]),
			beUint64(addr[8:]),
		},
		z: z6noz,
	}
}

// ipv6Slice类似于IPv6Raw，但在16字节的片上运行。假设
// slice为16字节，调用方必须执行此操作。
func ipv6Slice(addr []byte) Addr {
	return Addr{
		addr: uint128{
			beUint64(addr[:8]),
			beUint64(addr[8:]),
		},
		z: z6noz,
	}
}

// ParseAddr解析为IP地址，返回结果。字符串
// s可以是点十进制（“192.0.2.1”）、IPv6（“2001:db8:：68”）、
// 或带有范围寻址区的IPv6（“fe80:：1cc0:3e8c:119f:c2e1%ens18”）。
func ParseAddr(s string) (Addr, error) {
	for i := 0; i < len(s); i++ {
		switch s[i] {
		case '.':
			return parseIPv4(s)
		case ':':
			return parseIPv6(s)
		case '%':
			// 假设这是一个带有区域说明符的IPv6地址，但缺少该地址。
			return Addr{}, parseAddrError{in: s, msg: "missing IPv6 address"}
		}
	}
	return Addr{}, parseAddrError{in: s, msg: "unable to parse IP"}
}

// MustParseAddr调用ParseAddr并对错误感到恐慌。
// 用于硬编码字符串的测试。
func MustParseAddr(s string) Addr {
	ip, err := ParseAddr(s)
	if err != nil {
		panic(err)
	}
	return ip
}

type parseAddrError struct {
	in  string // 给定给ParseAddr的字符串
	msg string // 解析失败的解释
	at  string // 可选地，是in中发生错误的未解析部分。
}

func (err parseAddrError) Error() string {
	q := strconv.Quote
	if err.at != "" {
		return "ParseAddr(" + q(err.in) + "): " + err.msg + " (at " + q(err.at) + ")"
	}
	return "ParseAddr(" + q(err.in) + "): " + err.msg
}

// parseIPv4解析为IPv4地址（格式为“192.168.0.1”）。wen jian defg
func parseIPv4(s string) (ip Addr, err error) {
	var fields [4]uint8
	var val, pos int
	for i := 0; i < len(s); i++ {
		if s[i] >= '0' && s[i] <= '9' {
			if digLen == 1 && val == 0 {
				return Addr{}, parseAddrError{in: s, msg: "IPv4 field has octet with leading zero"}
			}
			val = val*10 + int(s[i]) - '0'
			digLen++
			if val > 255 {
				return Addr{}, parseAddrError{in: s, msg: "IPv4 field has value >255"}
			}
		} else if s[i] == '.' {
			// 1。。2.3 
			if i == 0 || i == len(s)-1 || s[i-1] == '.' {
				return Addr{}, parseAddrError{in: s, msg: "IPv4 field must have at least one digit", at: s[i:]}
			}
			// 1.2.3.4.5 
			if pos == 3 {
				return Addr{}, parseAddrError{in: s, msg: "IPv4 address too long"}
			}
			fields[pos] = uint8(val)
			pos++
			val = 0
			digLen = 0
		} else {
			return Addr{}, parseAddrError{in: s, msg: "unexpected character", at: s[i:]}
		}
	}
	if pos < 3 {
		return Addr{}, parseAddrError{in: s, msg: "IPv4 address too short"}
	}
	fields[3] = uint8(val)
	return AddrFrom4(fields), nil
}

// IPv6解析为IPv6地址（格式为“2001:db8:：68”）。
func parseIPv6(in string) (Addr, error) {
	s := in

	// 从一开始就把区域分开。是的，这是对字符串的第二次扫描，但是尝试以内联方式处理它会使大量的
	// 其他内部循环条件变得更昂贵，结果
	// 速度变慢。
	zone := ""
	i := bytealg.IndexByteString(s, '%')
	if i != -1 {
		s, zone = s[:i], s[i+1:]
		if zone == "" {
			// 如果明确指定，则不允许有空区域。
			return Addr{}, parseAddrError{in: in, msg: "zone must be a non-empty string"}
		}
	}

	var ip [16]byte
	ellipsis := -1 // 省略号在ip中的位置

	// 可能有前导省略号
	if len(s) >= 2 && s[0] == ':' && s[1] == ':' {
		ellipsis = 0
		s = s[2:]
		// 可能只是省略号
		if len(s) == 0 {
			return IPv6Unspecified().WithZone(zone), nil
		}
	}

	// 循环，解析后跟冒号的十六进制数。
	i = 0
	for i < 16 {
		// 十六进制数。与parseIPv4类似，内联十六进制数
		// 解析可以显著提高性能。
		off := 0
		acc := uint32(0)
		for ; off < len(s); off++ {
			c := s[off]
			if c >= '0' && c <= '9' {
				acc = (acc << 4) + uint32(c-'0')
			} else if c >= 'a' && c <= 'f' {
				acc = (acc << 4) + uint32(c-'a'+10)
			} else if c >= 'A' && c <= 'F' {
				acc = (acc << 4) + uint32(c-'A'+10)
			} else {
				break
			}
			if acc > math.MaxUint16 {
				// 溢出，失败。
				return Addr{}, parseAddrError{in: in, msg: "IPv6 field has value >=2^16", at: s}
			}
		}
		if off == 0 {
			// 找不到数字，失败。
			return Addr{}, parseAddrError{in: in, msg: "each colon-separated field must have at least one digit", at: s}
		}

		// 如果后跟点，则可能在后面的IPv4中。
		if off < len(s) && s[off] == '.' {
			if ellipsis < 0 && i != 12 {
				// 不是正确的地方。没有足够的空间。
				return Addr{}, parseAddrError{in: in, msg: "embedded IPv4 address must replace the final 2 fields of the address", at: s}
			}
			if i+4 > 16 {
				return Addr{}, parseAddrError{in: in, msg: "too many hex fields to fit an embedded IPv4 at the end of the address", at: s}
			}
			// TODO:如果有一个解析为[4]字节的助手
			// 并让parseIPv4和
			// parseIPv6使用它，可以让这个过程更快一些。
			ip4, err := parseIPv4(s)
			if err != nil {
				return Addr{}, parseAddrError{in: in, msg: err.Error(), at: s}
			}
			ip[i] = ip4.v4(0)
			ip[i+1] = ip4.v4(1)
			ip[i+2] = ip4.v4(2)
			ip[i+3] = ip4.v4(3)
			s = ""
			i += 4
			break
		}

		// 保存此16位块。
		ip[i] = byte(acc >> 8)
		ip[i+1] = byte(acc)
		i += 2

		// 在字符串末尾停止。
		s = s[off:]
		if len(s) == 0 {
			break
		}

		// 否则必须后跟冒号等。
		if s[0] != ':' {
			return Addr{}, parseAddrError{in: in, msg: "unexpected character, want colon", at: s}
		} else if len(s) == 1 {
			return Addr{}, parseAddrError{in: in, msg: "colon must be followed by more characters", at: s}
		}
		s = s[1:]

		// 寻找省略号。
		if s[0] == ':' {
			if ellipsis >= 0 { // 已经有一个
				return Addr{}, parseAddrError{in: in, msg: "multiple :: in address", at: s}
			}
			ellipsis = i
			s = s[1:]
			if len(s) == 0 { // 可以在末尾
				break
			}
		}
	}

	// 必须使用整个字符串。
	if len(s) != 0 {
		return Addr{}, parseAddrError{in: in, msg: "trailing garbage after address", at: s}
	}

	// 如果解析不够，请展开省略号。
	if i < 16 {
		if ellipsis < 0 {
			return Addr{}, parseAddrError{in: in, msg: "address string too short"}
		}
		n := 16 - i
		for j := i - 1; j >= ellipsis; j-- {
			ip[j+n] = ip[j]
		}
		for j := ellipsis + n - 1; j >= ellipsis; j-- {
			ip[j] = 0
		}
	} else if ellipsis >= 0 {
		// 省略号必须至少代表一个0组。
		return Addr{}, parseAddrError{in: in, msg: "the :: must expand to at least one field of zeros"}
	}
	return AddrFrom16(ip).WithZone(zone), nil
}

// AddrFromSlice将4字节或16字节的片解析为IPv4或IPv6地址。
// 请注意，一个网。IP可以直接作为[]字节参数传递。
// 如果slice的长度不是4或16，AddrFromSlice返回Addr{}，false。
func AddrFromSlice(slice []byte) (ip Addr, ok bool) {
	switch len(slice) {
	case 4:
		return AddrFrom4(*(*[4]byte)(slice)), true
	case 16:
		return ipv6Slice(slice), true
	}
	return Addr{}, false
}

// v4返回ip的第i个字节。如果ip不是IPv4，v4将返回
// 未指定的垃圾。
func (ip Addr) v4(i uint8) uint8 {
	return uint8(ip.addr.lo >> ((3 - i) * 8))
}

// v6返回ip的第i个字节。如果ip是IPv4地址，则此
// 访问ip的IPv4映射IPv6地址形式。
func (ip Addr) v6(i uint8) uint8 {
	return uint8(*(ip.addr.halves()[(i/8)%2]) >> ((7 - i%8) * 8))
}

// v6u16返回ip的第i个16位字。如果ip是IPv4地址，则
// 这将访问ip的IPv4映射IPv6地址形式。
func (ip Addr) v6u16(i uint8) uint16 {
	return uint16(*(ip.addr.halves()[(i/4)%2]) >> ((3 - i%4) * 16))
}

// isZero报告ip是否为ip类型的零值。
// 零值不是任何类型的有效IP地址。注意“0.0.0.0”和“：”不是零值。使用IsUnspecified来
// 检查这些值。
func (ip Addr) isZero() bool {
	// 比比较ip==Addr{}快，但实际上相当于
	// 因为无法从这个包中生成一个带有nil z的ip。
	return ip.z == z0
}

// IsValid报告Addr是否为初始化地址（而不是零Addr）。请注意，“0.0.0.0”和“：”都是有效值。
func (ip Addr) IsValid() bool { return ip.z != z0 }

// BitLen返回IP地址中的位数：
// 128表示IPv6，32表示IPv4，0表示零地址。
// 
// 注意，IPv4映射的IPv6地址被视为IPv6地址
// 因此位长为128。
func (ip Addr) BitLen() int {
	switch ip.z {
	case z0:
		return 0
	case z4:
		return 32
	}
	return 128
}

// Zone返回ip的IPv6作用域寻址区域（如果有）。
func (ip Addr) Zone() string {
	if ip.z == nil {
		return ""
	}
	zone, _ := ip.z.Get().(string)
	return zone
}

// Compare返回一个比较两个IP的整数。
// 如果ip==ip2，结果将为0；如果ip<ip2，结果将为1；如果ip>ip2，结果将为+1。
// 小于的定义与less方法相同。
func (ip Addr) Compare(ip2 Addr) int {
	f1, f2 := ip.BitLen(), ip2.BitLen()
	if f1 < f2 {
		return -1
	}
	if f1 > f2 {
		return 1
	}
	hi1, hi2 := ip.addr.hi, ip2.addr.hi
	if hi1 < hi2 {
		return -1
	}
	if hi1 > hi2 {
		return 1
	}
	lo1, lo2 := ip.addr.lo, ip2.addr.lo
	if lo1 < lo2 {
		return -1
	}
	if lo1 > lo2 {
		return 1
	}
	if ip.Is6() {
		za, zb := ip.Zone(), ip2.Zone()
		if za < zb {
			return -1
		}
		if za > zb {
			return 1
		}
	}
	return 0
}

// Less报告ip是否排序在ip2之前。
// IP地址先按长度排序，然后按地址排序。
// 带区域的IPv6地址仅在不带区域的同一地址之后排序。
func (ip Addr) Less(ip2 Addr) bool { return ip.Compare(ip2) == -1 }

func (ip Addr) lessOrEq(ip2 Addr) bool { return ip.Compare(ip2) <= 0 }

// Is4报告ip是否为IPv4地址。
// 
// 对于IP4映射的IPv6地址，它返回false。见IP。取消映射。
func (ip Addr) Is4() bool {
	return ip.z == z4
}

// Is4In6报告ip是否为IPv4映射的IPv6地址。
func (ip Addr) Is4In6() bool {
	return ip.Is6() && ip.addr.hi == 0 && ip.addr.lo>>32 == 0xffff
}

// Is6报告ip是否为IPv6地址，包括IPv4映射的
// IPv6地址。
func (ip Addr) Is6() bool {
	return ip.z != z0 && ip.z != z4
}

// 取消映射返回删除了所有IPv4映射IPv6地址前缀的ip。
// 
// 也就是说，如果ip是包装IPv4地址的IPv6地址，则返回包装后的IPv4地址。否则它将返回未修改的ip。
func (ip Addr) Unmap() Addr {
	if ip.Is4In6() {
		ip.z = z4
	}
	return ip
}

// WithZone返回一个与IP相同的IP，但带有提供的
// zone。如果区域为空，则删除该区域。如果ip是IPv4 
// 地址，WithZone是no op，返回ip不变。
func (ip Addr) WithZone(zone string) Addr {
	if !ip.Is6() {
		return ip
	}
	if zone == "" {
		ip.z = z6noz
		return ip
	}
	ip.z = intern.GetByString(zone)
	return ip
}

// withoutZone无条件从IP中删除该区域。
// 它与WithZone类似，但小到可以插入。
func (ip Addr) withoutZone() Addr {
	if !ip.Is6() {
		return ip
	}
	ip.z = z6noz
	return ip
}

// hasZone报告IP是否有IPv6区域。
func (ip Addr) hasZone() bool {
	return ip.z != z0 && ip.z != z4 && ip.z != z6noz
}

// IsLinkLocalUnicast报告ip是否为链路本地单播地址。
func (ip Addr) IsLinkLocalUnicast() bool {
	// IPv4链路本地地址的动态配置
	// https:
	if ip.Is4() {
		return ip.v4(0) == 169 && ip.v4(1) == 254
	}
	// IP版本6寻址体系结构（2.4地址类型标识）
	// https:
	if ip.Is6() {
		return ip.v6u16(0)&0xffc0 == 0xfe80
	}
	return false // 零值
}

// IsLoopback报告ip是否为环回地址。
func (ip Addr) IsLoopback() bool {
	// 对Internet主机的要求——通信层（3.2.1.3寻址）
	// https:
	if ip.Is4() {
		return ip.v4(0) == 127
	}
	// IP版本6寻址体系结构（2.4地址类型标识）
	// https:
	if ip.Is6() {
		return ip.addr.hi == 0 && ip.addr.lo == 1
	}
	return false // 零值
}

// IsMulticast报告IP是否为多播地址。
func (ip Addr) IsMulticast() bool {
	// IP多播主机扩展（4.主机组地址）
	// https:
	if ip.Is4() {
		return ip.v4(0)&0xf0 == 0xe0
	}
	// IP版本6寻址体系结构（2.4地址类型标识）
	// https:
	if ip.Is6() {
		return ip.addr.hi>>(64-8) == 0xff // IP。v6（0）==0xff 
	}
	return false // 零值
}

// IsInterfaceLocalMulticast报告ip是否为IPv6接口本地
// 多播地址。
func (ip Addr) IsInterfaceLocalMulticast() bool {
	// IPv6寻址体系结构（2.7.1.预定义的多播地址）
	// https:
	if ip.Is6() {
		return ip.v6u16(0)&0xff0f == 0xff01
	}
	return false // 零值
}

// IsLinkLocalMulticast报告ip是否为链路本地多播地址。
func (ip Addr) IsLinkLocalMulticast() bool {
	// IPv4多播指南（4.本地网络控制块（224.0.0/24））
	// https:
	if ip.Is4() {
		return ip.v4(0) == 224 && ip.v4(1) == 0 && ip.v4(2) == 0
	}
	// IPv6寻址体系结构（2.7.1.预定义多播地址）
	// https:
	if ip.Is6() {
		return ip.v6u16(0)&0xff0f == 0xff02
	}
	return false // 零值
}

// IsGlobalUnicast报告ip是否为全局单播地址。
// 
// 对于当前
// IANA分配的2000:：/3全局单播空间之外的IPv6地址，返回true，但
// 链路本地地址空间除外。即使ip位于IPv4 
// 专用地址空间或IPv6唯一本地地址空间中，它也会返回true。
// 对于零地址返回false。
// 
// 参考RFC 1122、RFC 4291和RFC 4632。
func (ip Addr) IsGlobalUnicast() bool {
	if ip.z == z0 {
		// 无效或为零值。
		return false
	}

	// 匹配package net的IsGlobalUnicast逻辑。值得注意的是，私有IPv4地址
	// 和ULA IPv6地址仍然被视为“全局单播”。根据RFC 1918 
	if ip.Is4() && (ip == IPv4Unspecified() || ip == AddrFrom4([4]byte{255, 255, 255, 255})) {
		return false
	}

	return ip != IPv6Unspecified() &&
		!ip.IsLoopback() &&
		!ip.IsMulticast() &&
		!ip.IsLinkLocalUnicast()
}

// （IPv4地址）和RFC 4193（IPv6地址），iPrivate报告ip是否为专用地址。也就是说，它报告
// ip是否在10.0.0.0/8、172.16.0.0/12、192.168.0.0/16或fc00:：/7中。这是
// 与net相同。IP。我是私人的。
func (ip Addr) IsPrivate() bool {
	// 匹配stdlib的iPrivate逻辑。
	if ip.Is4() {
		// RFC 1918将10.0.0.0/8、172.16.0.0/12和192.168.0.0/16分配为
		// 专用IPv4地址子网。
		return ip.v4(0) == 10 ||
			(ip.v4(0) == 172 && ip.v4(1)&0xf0 == 16) ||
			(ip.v4(0) == 192 && ip.v4(1) == 168)
	}

	if ip.Is6() {
		// RFC 4193将fc00:：/7分配为唯一的本地单播IPv6地址
		// 子网。
		return ip.v6(0)&0xfe == 0xfc
	}

	return false // 零值
}

// IsUnspecified报告ip是否为未指定地址，IPv4 
// 地址“0.0.0.0”或IPv6地址：“：”。
// 
// 请注意，零地址不是未指定的地址。
func (ip Addr) IsUnspecified() bool {
	return ip == IPv4Unspecified() || ip == IPv6Unspecified()
}

// 前缀只保留IP的前b位，生成指定长度的前缀
// 。
// 如果ip是零地址，Prefix总是返回零前缀和零错误。
// 否则，如果位小于零或大于ip。BitLen（），
// 前缀返回错误。
func (ip Addr) Prefix(b int) (Prefix, error) {
	if b < 0 {
		return Prefix{}, errors.New("negative Prefix bits")
	}
	effectiveBits := b
	switch ip.z {
	case z0:
		return Prefix{}, nil
	case z4:
		if b > 32 {
			return Prefix{}, errors.New("prefix length " + itoa.Itoa(b) + " too large for IPv4")
		}
		effectiveBits += 96
	default:
		if b > 128 {
			return Prefix{}, errors.New("prefix length " + itoa.Itoa(b) + " too large for IPv6")
		}
	}
	ip.addr = ip.addr.and(mask6(effectiveBits))
	return PrefixFrom(ip, b), nil
}

const (
	netIPv4len = 4
	netIPv6len = 16
)

// As16以16字节的形式返回IP地址。
// IPv4地址以v6映射形式返回。
// 带区域的IPv6地址返回时不带区域（使用
// zone方法获取）。
// ip零值返回所有零。
func (ip Addr) As16() (a16 [16]byte) {
	bePutUint64(a16[:8], ip.addr.hi)
	bePutUint64(a16[8:], ip.addr.lo)
	return a16
}

// As4以4字节表示形式返回IPv4或IPv6中的IPv4地址。
// 如果ip是零地址或IPv6地址，则As4恐慌。
// 请注意，0.0.0.0不是零地址。
func (ip Addr) As4() (a4 [4]byte) {
	if ip.z == z4 || ip.Is4In6() {
		bePutUint32(a4[:], uint32(ip.addr.lo))
		return a4
	}
	if ip.z == z0 {
		panic("As4 called on IP zero value")
	}
	panic("As4 called on IPv6 address")
}

// AsSlice以其各自的4字节或16字节表示形式返回IPv4或IPv6地址。
func (ip Addr) AsSlice() []byte {
	switch ip.z {
	case z0:
		return nil
	case z4:
		var ret [4]byte
		bePutUint32(ret[:], uint32(ip.addr.lo))
		return ret[:]
	default:
		var ret [16]byte
		bePutUint64(ret[:8], ip.addr.hi)
		bePutUint64(ret[8:], ip.addr.lo)
		return ret[:]
	}
}

// 下一步返回ip后面的地址。
// 如果没有，则返回零地址。
func (ip Addr) Next() Addr {
	ip.addr = ip.addr.addOne()
	if ip.Is4() {
		if uint32(ip.addr.lo) == 0 {
			// 溢出。
			return Addr{}
		}
	} else {
		if ip.addr.isZero() {
			// 溢出
			return Addr{}
		}
	}
	return ip
}

// Prev返回IP之前的IP。
// 如果没有，则返回IP零值。
func (ip Addr) Prev() Addr {
	if ip.Is4() {
		if uint32(ip.addr.lo) == 0 {
			return Addr{}
		}
	} else if ip.addr.isZero() {
		return Addr{}
	}
	ip.addr = ip.addr.subOne()
	return ip
}

// String返回IP地址的字符串形式。
// 返回5种表单之一：
// 
// /-“无效IP”，如果ip是零地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址地址。字符串方法
// IP4映射的IPv6地址格式，带“：：ffff:”
// 前缀，位于虚线四元组之前。
func (ip Addr) String() string {
	switch ip.z {
	case z0:
		return "invalid IP"
	case z4:
		return ip.string4()
	default:
		if ip.Is4In6() {
			// TODO（布拉德菲茨）：这可能会减少分配。
			if z := ip.Zone(); z != "" {
				return "::ffff:" + ip.Unmap().String() + "%" + z
			} else {
				return "::ffff:" + ip.Unmap().String()
			}
		}
		return ip.string6()
	}
}

// AppendTo将MarshalText生成的ip文本编码
// 追加到b，并返回扩展缓冲区。
func (ip Addr) AppendTo(b []byte) []byte {
	switch ip.z {
	case z0:
		return b
	case z4:
		return ip.appendTo4(b)
	default:
		if ip.Is4In6() {
			b = append(b, "::ffff:"...)
			b = ip.Unmap().appendTo4(b)
			if z := ip.Zone(); z != "" {
				b = append(b, '%')
				b = append(b, z...)
			}
			return b
		}
		return ip.appendTo6(b)
	}
}

// 数字是从0到f的十六进制数字字符串。它用于
// appendDecimal和appendHex来格式化IP地址。
const digits = "0123456789abcdef"

// appendDecimal将x的十进制字符串表示形式追加到b。
func appendDecimal(b []byte, x uint8) []byte {
	// 使用此函数而不是strconv。AppendUint使IPv4 
	// 字符串生成速度提高了2倍。

	if x >= 100 {
		b = append(b, digits[x/100])
	}
	if x >= 10 {
		b = append(b, digits[x/10%10])
	}
	return append(b, digits[x%10])
}

// appendHex将x的十六进制字符串表示形式追加到b。
func appendHex(b []byte, x uint16) []byte {
	// 使用此函数而不是strconv。AppendUint使IPv6 
	// 字符串生成速度提高了2倍。

	if x >= 0x1000 {
		b = append(b, digits[x>>12])
	}
	if x >= 0x100 {
		b = append(b, digits[x>>8&0xf])
	}
	if x >= 0x10 {
		b = append(b, digits[x>>4&0xf])
	}
	return append(b, digits[x&0xf])
}

// appendHexPad将完全填充的十六进制字符串表示形式x追加到b。
func appendHexPad(b []byte, x uint16) []byte {
	return append(b, digits[x>>12], digits[x>>8&0xf], digits[x>>4&0xf], digits[x&0xf])
}

func (ip Addr) string4() string {
	const max = len("255.255.255.255")
	ret := make([]byte, 0, max)
	ret = ip.appendTo4(ret)
	return string(ret)
}

func (ip Addr) appendTo4(ret []byte) []byte {
	ret = appendDecimal(ret, ip.v4(0))
	ret = append(ret, '.')
	ret = appendDecimal(ret, ip.v4(1))
	ret = append(ret, '.')
	ret = appendDecimal(ret, ip.v4(2))
	ret = append(ret, '.')
	ret = appendDecimal(ret, ip.v4(3))
	return ret
}

// string6以IPv6文本表示形式格式化ip。它遵循RFC 5952 
// tools.ietf.org/html/rfc5952#section-4） ：没有不必要的
// /第4节中的
// 零，使用：：删除最长的零，不要使用：：
// 压缩单个零字段。
func (ip Addr) string6() string {
	// 使用一个名称“似乎很长”的区域，这样大多数区域完整的
	// IP地址就不需要额外分配。
	// 
	// 编译器在这里做了一个很酷的优化，ret最终得到了
	// 堆栈分配，所以这个函数唯一的分配就是构造返回的字符串。因此，在这里做一个
	// 就尺寸而言有点贪婪是可以的。
	const max = len("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff%enp5s0")
	ret := make([]byte, 0, max)
	ret = ip.appendTo6(ret)
	return string(ret)
}

func (ip Addr) appendTo6(ret []byte) []byte {
	zeroStart, zeroEnd := uint8(255), uint8(255)
	for i := uint8(0); i < 8; i++ {
		j := i
		for j < 8 && ip.v6u16(j) == 0 {
			j++
		}
		if l := j - i; l >= 2 && l > zeroEnd-zeroStart {
			zeroStart, zeroEnd = i, j
		}
	}

	for i := uint8(0); i < 8; i++ {
		if i == zeroStart {
			ret = append(ret, ':', ':')
			i = zeroEnd
			if i >= 8 {
				break
			}
		} else if i > 0 {
			ret = append(ret, ':')
		}

		ret = appendHex(ret, ip.v6u16(i))
	}

	if ip.z != z6noz {
		ret = append(ret, '%')
		ret = append(ret, ip.Zone()...)
	}
	return ret
}

// StringExpanded与String类似，但IPv6地址是用前导的
// 0和no展开的：“压缩”。例如，“2001:db8:：1”变成
// /“2001:0db8:0000:0000:0000:0000:0001”。
func (ip Addr) StringExpanded() string {
	switch ip.z {
	case z0, z4:
		return ip.String()
	}

	const size = len("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
	ret := make([]byte, 0, size)
	for i := uint8(0); i < 8; i++ {
		if i > 0 {
			ret = append(ret, ':')
		}

		ret = appendHexPad(ret, ip.v6u16(i))
	}

	if ip.z != z6noz {
		// 添加一个区域将导致第二次分配，但当没有区域时，ret切片将被堆栈分配。
		ret = append(ret, '%')
		ret = append(ret, ip.Zone()...)
	}
	return string(ret)
}

// MarshalText实现了编码。TextMarshaler接口，
// 编码与字符串返回的编码相同，只有一个例外：
// 如果ip是零地址，则编码为空字符串。
func (ip Addr) MarshalText() ([]byte, error) {
	switch ip.z {
	case z0:
		return []byte(""), nil
	case z4:
		max := len("255.255.255.255")
		b := make([]byte, 0, max)
		return ip.appendTo4(b), nil
	default:
		max := len("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff%enp5s0")
		b := make([]byte, 0, max)
		if ip.Is4In6() {
			b = append(b, "::ffff:"...)
			b = ip.Unmap().appendTo4(b)
			if z := ip.Zone(); z != "" {
				b = append(b, '%')
				b = append(b, z...)
			}
			return b, nil
		}
		return ip.appendTo6(b), nil
	}

}

// UnmarshalText实现编码。TextUnmarshaler接口。
// IP地址应为ParseAddr接受的格式。
// 
// 如果文本为空，UnmarshalText将*ip设置为零地址，
// 不返回任何错误。
func (ip *Addr) UnmarshalText(text []byte) error {
	if len(text) == 0 {
		*ip = Addr{}
		return nil
	}
	var err error
	*ip, err = ParseAddr(string(text))
	return err
}

func (ip Addr) marshalBinaryWithTrailingBytes(trailingBytes int) []byte {
	var b []byte
	switch ip.z {
	case z0:
		b = make([]byte, trailingBytes)
	case z4:
		b = make([]byte, 4+trailingBytes)
		bePutUint32(b, uint32(ip.addr.lo))
	default:
		z := ip.Zone()
		b = make([]byte, 16+len(z)+trailingBytes)
		bePutUint64(b[:8], ip.addr.hi)
		bePutUint64(b[8:], ip.addr.lo)
		copy(b[16:], z)
	}
	return b
}

// MarshalBinary实现了编码。BinaryMarshaler接口。
// 它返回零地址的零长度片，
// IPv4地址的4字节格式，
// 以及IPv6地址附加区域的16字节格式。
func (ip Addr) MarshalBinary() ([]byte, error) {
	return ip.marshalBinaryWithTrailingBytes(0), nil
}

// 解包二进制实现编码。BinaryUnmarshaler接口。
// 它需要MarshalBinary生成的格式的数据。
func (ip *Addr) UnmarshalBinary(b []byte) error {
	n := len(b)
	switch {
	case n == 0:
		*ip = Addr{}
		return nil
	case n == 4:
		*ip = AddrFrom4(*(*[4]byte)(b))
		return nil
	case n == 16:
		*ip = ipv6Slice(b)
		return nil
	case n > 16:
		*ip = ipv6Slice(b[:16]).WithZone(string(b[16:]))
		return nil
	}
	return errors.New("unexpected slice size")
}

// AddrPort是一个IP和一个端口号。
type AddrPort struct {
	ip   Addr
	port uint16
}

// AddrPortFrom返回一个带有提供的IP和端口的AddrPort。
// 它不分配。
func AddrPortFrom(ip Addr, port uint16) AddrPort { return AddrPort{ip: ip, port: port} }

// Addr返回p的IP地址。
func (p AddrPort) Addr() Addr { return p.ip }

// 端口返回p的端口。
func (p AddrPort) Port() uint16 { return p.port }

// splitAddrPort拆分为IP地址字符串和端口
// string。它分割形状像“foo:bar”或“[foo]：bar”、
// 的字符串，而不进一步验证子字符串。v6指示
// ip字符串应解析为IPv6地址还是IPv4地址，顺序为s为有效的ip:端口字符串。
func splitAddrPort(s string) (ip, port string, v6 bool, err error) {
	i := stringsLastIndexByte(s, ':')
	if i == -1 {
		return "", "", false, errors.New("not an ip:port")
	}

	ip, port = s[:i], s[i+1:]
	if len(ip) == 0 {
		return "", "", false, errors.New("no IP")
	}
	if len(port) == 0 {
		return "", "", false, errors.New("no port")
	}
	if ip[0] == '[' {
		if len(ip) < 2 || ip[len(ip)-1] != ']' {
			return "", "", false, errors.New("missing ]")
		}
		ip = ip[1 : len(ip)-1]
		v6 = true
	}

	return ip, port, v6, nil
}

// ParseAddrPort解析为AddrPort。
// 
// 它不进行任何名称解析：地址和端口
// 必须是数字。
func ParseAddrPort(s string) (AddrPort, error) {
	var ipp AddrPort
	ip, port, v6, err := splitAddrPort(s)
	if err != nil {
		return ipp, err
	}
	port16, err := strconv.ParseUint(port, 10, 16)
	if err != nil {
		return ipp, errors.New("invalid port " + strconv.Quote(port) + " parsing " + strconv.Quote(s))
	}
	ipp.port = uint16(port16)
	ipp.ip, err = ParseAddr(ip)
	if err != nil {
		return AddrPort{}, err
	}
	if v6 && ipp.ip.Is4() {
		return AddrPort{}, errors.New("invalid ip:port " + strconv.Quote(s) + ", square brackets can only be used with IPv6 addresses")
	} else if !v6 && ipp.ip.Is6() {
		return AddrPort{}, errors.New("invalid ip:port " + strconv.Quote(s) + ", IPv6 addresses must be surrounded by square brackets")
	}
	return ipp, nil
}

// MustParseAddrPort调用ParseAddrPort并在出现错误时惊慌失措。
// 用于硬编码字符串的测试。
func MustParseAddrPort(s string) AddrPort {
	ip, err := ParseAddrPort(s)
	if err != nil {
		panic(err)
	}
	return ip
}

// isZero报告p是否为零AddrPort。
func (p AddrPort) isZero() bool { return p == AddrPort{} }

// IsValid报告p.IP（）是否有效。
// 所有端口均有效，包括零。
func (p AddrPort) IsValid() bool { return p.ip.IsValid() }

func (p AddrPort) String() string {
	switch p.ip.z {
	case z0:
		return "invalid AddrPort"
	case z4:
		a := p.ip.As4()
		buf := make([]byte, 0, 21)
		for i := range a {
			buf = strconv.AppendUint(buf, uint64(a[i]), 10)
			buf = append(buf, "...:"[i])
		}
		buf = strconv.AppendUint(buf, uint64(p.port), 10)
		return string(buf)
	default:
		// TODO:这在分配方面可能更有效：
		return joinHostPort(p.ip.String(), itoa.Itoa(int(p.port)))
	}
}

func joinHostPort(host, port string) string {
	// 如果主机有
	// 冒号，我们假设主机是一个文本IPv6地址。
	if bytealg.IndexByteString(host, ':') >= 0 {
		return "[" + host + "]:" + port
	}
	return host + ":" + port
}

// AppendTo将MarshalText生成的p，
// 文本编码追加到b，并返回扩展缓冲区。
func (p AddrPort) AppendTo(b []byte) []byte {
	switch p.ip.z {
	case z0:
		return b
	case z4:
		b = p.ip.appendTo4(b)
	default:
		if p.ip.Is4In6() {
			b = append(b, "[::ffff:"...)
			b = p.ip.Unmap().appendTo4(b)
			if z := p.ip.Zone(); z != "" {
				b = append(b, '%')
				b = append(b, z...)
			}
		} else {
			b = append(b, '[')
			b = p.ip.appendTo6(b)
		}
		b = append(b, ']')
	}
	b = append(b, ':')
	b = strconv.AppendInt(b, int64(p.port), 10)
	return b
}

// MarshalText实现了编码。TextMarshaler接口。
// 编码与字符串返回的编码相同，只有一个例外：if 
// p.Addr（）是零Addr，编码是空字符串。
func (p AddrPort) MarshalText() ([]byte, error) {
	var max int
	switch p.ip.z {
	case z0:
	case z4:
		max = len("255.255.255.255:65535")
	default:
		max = len("[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff%enp5s0]:65535")
	}
	b := make([]byte, 0, max)
	b = p.AppendTo(b)
	return b, nil
}

// UnmarshalText实现编码。TextUnmarshaler 
// 接口。AddrPort的格式应为
// 由MarshalText生成或由ParseAddrPort接受。
func (p *AddrPort) UnmarshalText(text []byte) error {
	if len(text) == 0 {
		*p = AddrPort{}
		return nil
	}
	var err error
	*p, err = ParseAddrPort(string(text))
	return err
}

// MarshalBinary实现了编码。BinaryMarshaler接口。
// 返回Addr。MarshalBinary，附加了两个字节
// 包含端口的little endian格式。
func (p AddrPort) MarshalBinary() ([]byte, error) {
	b := p.Addr().marshalBinaryWithTrailingBytes(2)
	lePutUint16(b[len(b)-2:], p.Port())
	return b, nil
}

// 解包二进制实现编码。BinaryUnmarshaler接口。
// 它需要MarshalBinary生成的格式的数据。
func (p *AddrPort) UnmarshalBinary(b []byte) error {
	if len(b) < 2 {
		return errors.New("unexpected slice size")
	}
	var addr Addr
	err := addr.UnmarshalBinary(b[:len(b)-2])
	if err != nil {
		return err
	}
	*p = AddrPortFrom(addr, leUint16(b[len(b)-2:]))
	return nil
}

// 前缀是代表IP网络的IP地址前缀（CIDR）。
// 
// 指定Addr（）的第一位（）。剩余的位匹配任何地址。
// 位的范围（）对于IPv4为[0,32]，对于IPv6为[0128]。
type Prefix struct {
	ip Addr

	// 位在逻辑上是一个uint8（存储[0128]），但
	// 编码一个“无效”位，当前由
	// invalidPrefixBits前哨值表示。它可以用更复杂的表达式打包到uint8的
	// 
	// 访问器中，但额外的字节（无论如何都是填充的）不会伤害并简化下面的代码。
	bits int16
}

// invalidPrefixBits是前缀。当PrefixFrom为
// 超出uint8范围时使用的位值。它在
// 公共API中作为int-1返回。
const invalidPrefixBits = -1

// PrefixFrom返回一个带有提供的IP地址和位
// 前缀长度的前缀。
// 
// 它不分配。不像Addr。Prefix，PrefixFrom不屏蔽
// ip的主机位。
// 
// 如果位小于零或大于ip。比特伦，前缀。位
// 将返回无效值-1。
func PrefixFrom(ip Addr, bits int) Prefix {
	if bits < 0 || bits > ip.BitLen() {
		bits = invalidPrefixBits
	}
	b16 := int16(bits)
	return Prefix{
		ip:   ip.withoutZone(),
		bits: b16,
	}
}

// Addr返回p的IP地址。
func (p Prefix) Addr() Addr { return p.ip }

// 位返回p的前缀长度。
// 
// 如果无效，则报告-1。
func (p Prefix) Bits() int { return int(p.bits) }

// IsValid报告p.Bits（）是否具有p.IP（）的有效范围。
// 如果p.Addr（）是零Addr，IsValid返回false。
// 注意，如果p是零前缀，那么p.IsValid（）==false。
func (p Prefix) IsValid() bool { return !p.ip.isZero() && p.bits >= 0 && int(p.bits) <= p.ip.BitLen() }

func (p Prefix) isZero() bool { return p == Prefix{} }

// IsSingleIP报告p是否只包含一个IP。
func (p Prefix) IsSingleIP() bool { return p.bits != 0 && int(p.bits) == p.ip.BitLen() }

// 解析前缀解析为IP地址前缀。
// 字符串的格式可以是“192.168.1.0/24”或“2001:db8:：/32”，
// RFC 4632和RFC 4291中定义的CIDR符号。
// 
// 请注意，屏蔽地址位不归零。戴上面具。
func ParsePrefix(s string) (Prefix, error) {
	i := stringsLastIndexByte(s, '/')
	if i < 0 {
		return Prefix{}, errors.New("netip.ParsePrefix(" + strconv.Quote(s) + "): no '/'")
	}
	ip, err := ParseAddr(s[:i])
	if err != nil {
		return Prefix{}, errors.New("netip.ParsePrefix(" + strconv.Quote(s) + "): " + err.Error())
	}
	bitsStr := s[i+1:]
	bits, err := strconv.Atoi(bitsStr)
	if err != nil {
		return Prefix{}, errors.New("netip.ParsePrefix(" + strconv.Quote(s) + ": bad bits after slash: " + strconv.Quote(bitsStr))
	}
	maxBits := 32
	if ip.Is6() {
		maxBits = 128
	}
	if bits < 0 || bits > maxBits {
		return Prefix{}, errors.New("netip.ParsePrefix(" + strconv.Quote(s) + ": prefix length out of range")
	}
	return PrefixFrom(ip, bits), nil
}

// MustParsePrefix调用ParsePrefix并在出现错误时惊慌失措。
// 用于硬编码字符串的测试。
func MustParsePrefix(s string) Prefix {
	ip, err := ParsePrefix(s)
	if err != nil {
		panic(err)
	}
	return ip
}

// Masked以其标准形式返回p，除p.Addr（）的高位
// p.Bits（）位被屏蔽。
// 
// 如果p为零或无效，Masked返回零前缀。
func (p Prefix) Masked() Prefix {
	if m, err := p.ip.Prefix(int(p.bits)); err == nil {
		return m
	}
	return Prefix{}
}

// 包含网络p是否包含ip的报告。
// 
// IPv4地址与IPv6前缀不匹配。
// v6映射的IPv6地址与IPv4前缀不匹配。
// 零值IP将不匹配任何前缀。
// 如果ip有IPv6区域，Contains返回false，
// 因为前缀是strip zones。
func (p Prefix) Contains(ip Addr) bool {
	if !p.IsValid() || ip.hasZone() {
		return false
	}
	if f1, f2 := p.ip.BitLen(), ip.BitLen(); f1 == 0 || f2 == 0 || f1 != f2 {
		return false
	}
	if ip.Is4() {
		// 将IP地址异或在一起；不匹配的位现在是1。
		// 移开我们不关心的位数。
		// 如果编译器能够证明移位量小于移位类型的宽度（此处为64），则Go中的移位效率更高。
		// 我们知道p.位在0的范围内。。32因为p是有效的；
		// 编译器不知道这一点，所以用63来帮助它。
		// 现在截断为32位，因为这是IPv4。
		// 如果我们关心的所有位都相等，结果将为零。
		return uint32((ip.addr.lo^p.ip.addr.lo)>>((32-p.bits)&63)) == 0
	} else {
		// 将IP地址异或在一起。
		// 掩盖掉我们不在乎的点点滴滴。
		// 如果我们关心的所有位都相等，结果将为零。
		return ip.addr.xor(p.ip.addr).and(mask6(int(p.bits))).isZero()
	}
}

// 重叠报告p和o是否包含任何共同的IP地址。
// 
// 如果p和o属于不同的地址族，或者IP为零，则报告为假。与Contains方法一样，带有
// v6映射的IPv4 IP的前缀仍被视为IPv6掩码。
func (p Prefix) Overlaps(o Prefix) bool {
	if !p.IsValid() || !o.IsValid() {
		return false
	}
	if p == o {
		return true
	}
	if p.ip.Is4() != o.ip.Is4() {
		return false
	}
	var minBits int16
	if p.bits < o.bits {
		minBits = p.bits
	} else {
		minBits = o.bits
	}
	if minBits == 0 {
		return true
	}
	// 其中一个前缀调用可能看起来多余，但我们不需要
	// 首先对p和o值进行规范化（通过Prefix.Masked），
	// 因此，对已经是minBits的一个进行前缀调用可以将
	// 去掉IP中的任何剩余位。
	var err error
	if p, err = p.ip.Prefix(int(minBits)); err != nil {
		return false
	}
	if o, err = o.ip.Prefix(int(minBits)); err != nil {
		return false
	}
	return p.ip == o.ip
}

// AppendTo将MarshalText生成的p，
// 文本编码追加到b，并返回扩展缓冲区。
func (p Prefix) AppendTo(b []byte) []byte {
	if p.isZero() {
		return b
	}
	if !p.IsValid() {
		return append(b, "invalid Prefix"...)
	}

	// p.ip是非零的，因为p是有效的。
	if p.ip.z == z4 {
		b = p.ip.appendTo4(b)
	} else {
		if p.ip.Is4In6() {
			b = append(b, "::ffff:"...)
			b = p.ip.Unmap().appendTo4(b)
		} else {
			b = p.ip.appendTo6(b)
		}
	}

	b = append(b, '/')
	b = appendDecimal(b, uint8(p.bits))
	return b
}

// MarshalText实现了编码。TextMarshaler接口，
// 编码与字符串返回的编码相同，只有一个例外：
// 如果p为零值，则编码为空字符串。
func (p Prefix) MarshalText() ([]byte, error) {
	var max int
	switch p.ip.z {
	case z0:
	case z4:
		max = len("255.255.255.255/32")
	default:
		max = len("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff%enp5s0/128")
	}
	b := make([]byte, 0, max)
	b = p.AppendTo(b)
	return b, nil
}

// UnmarshalText实现编码。TextUnmarshaler接口。
// IP地址应采用ParsePrefix 
// 接受的格式，或由MarshalText生成。
func (p *Prefix) UnmarshalText(text []byte) error {
	if len(text) == 0 {
		*p = Prefix{}
		return nil
	}
	var err error
	*p, err = ParsePrefix(string(text))
	return err
}

// MarshalBinary实现了编码。BinaryMarshaler接口。
// 返回Addr。MarshalBinary，附加字节
// 包含前缀位。
func (p Prefix) MarshalBinary() ([]byte, error) {
	b := p.Addr().withoutZone().marshalBinaryWithTrailingBytes(1)
	b[len(b)-1] = uint8(p.Bits())
	return b, nil
}

// 解包二进制实现编码。BinaryUnmarshaler接口。
// 它需要MarshalBinary生成的格式的数据。
func (p *Prefix) UnmarshalBinary(b []byte) error {
	if len(b) < 1 {
		return errors.New("unexpected slice size")
	}
	var addr Addr
	err := addr.UnmarshalBinary(b[:len(b)-1])
	if err != nil {
		return err
	}
	*p = PrefixFrom(addr, int(b[len(b)-1]))
	return nil
}

// 字符串返回p的CIDR表示法：“<ip>/<bits>”。
func (p Prefix) String() string {
	if !p.IsValid() {
		return "invalid Prefix"
	}
	return p.ip.String() + "/" + itoa.Itoa(int(p.bits))
}
